package com.zcloud.eventstudydemo.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.zcloud.eventstudydemo.dto.RestWebResponse;
import com.zcloud.eventstudydemo.entity.Event;
import com.zcloud.eventstudydemo.llm.AnalysisResult;
import com.zcloud.eventstudydemo.llm.AnalyzeLLMApi;
import com.zcloud.eventstudydemo.mapper.EventMapper;
import com.zcloud.eventstudydemo.util.HanLPKeywordExtractor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.*;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.*;

@RestController
@RequestMapping("/api/events")
public class EventController {

    @Autowired
    private EventMapper eventMapper;

    /**
     * 虚假的大模型对话接口
     *
     * @param question 用户提问的问题
     * @return 基于关键字查询数据库后生成的回答
     */
    @GetMapping("/chat")
    public RestWebResponse<JSONObject> chatWithModel(String question) {
        // 提取关键字（使用HanLP NLP技术）
        List<String> keywords = HanLPKeywordExtractor.extractKeywordsByTextRank(question, 5);

        // 根据关键字查询数据库
        List<Event> events = searchEventsByKeywords(keywords);

        // 生成自然语言回答
        String response = generateResponse(question, events);
        JSONObject responseJson = new JSONObject();
        responseJson.put("response", response);
        responseJson.put("events", events.size() > 5 ? events.subList(0, 5) : events);
        return RestWebResponse.success(responseJson);
    }

    /**
     * 使用多个关键词查询事件
     *
     * @param keywords 关键词列表
     * @return 匹配的事件列表
     */
    private List<Event> searchEventsByKeywords(List<String> keywords) {
        if (keywords == null || keywords.isEmpty()) {
            return new ArrayList<>();
        }
        QueryWrapper<Event> wrapper = new QueryWrapper<>();
        // 构建查询条件，所有关键词使用OR连接
        for (int i = 0; i < keywords.size(); i++) {
            String keyword = keywords.get(i);
            if (i == 0) {
                // 第一个关键词
                wrapper.like("event_name", keyword)
                        .or().like("event_type_name", keyword)
                        .or().like("related_person", keyword)
                        .or().like("event_content", keyword);
            } else {
                // 后续关键词都使用OR连接
                wrapper.or().nested(w -> w.like("event_name", keyword)
                        .or().like("event_type_name", keyword)
                        .or().like("related_person", keyword)
                        .or().like("event_content", keyword));
            }
        }

        wrapper.orderByDesc("create_time");
        wrapper.last("LIMIT 20"); // 限制最多返回20条记录
        return eventMapper.selectList(wrapper);
    }


    /**
     * 根据查询结果生成自然语言回答
     *
     * @param keyword 关键字
     * @param events  查询到的事件列表
     * @return 自然语言回答
     */
    private String generateResponse(String keyword, List<Event> events) {
        StringBuilder response = new StringBuilder();
        response.append("根据您的问题 \"").append(keyword).append("\"，我为您找到以下相关信息：\n\n");

        if (events.isEmpty()) {
            response = new StringBuilder();
            response.append("抱歉，没有找到与 \"").append(keyword).append("\" 相关的事件信息。");
        } else {
            response.append("共找到 ").append(events.size()).append(" 条相关事件记录：\n\n");
            for (int i = 0; i < Math.min(events.size(), 5); i++) { // 最多显示5条记录
                Event event = events.get(i);
                response.append("【事件 #").append(i + 1).append("】\n");
                response.append("  名称: ").append(event.getEventName()).append("\n");
                response.append("  类型: ").append(event.getEventType()).append("\n");
                response.append("  相关人员: ").append(event.getRelatedPerson()).append("\n");

                if (event.getTimeStart() != null) {
                    response.append("  开始时间: ").append(event.getTimeStart()).append("\n");
                }

                if (event.getTimeEnd() != null) {
                    response.append("  结束时间: ").append(event.getTimeEnd()).append("\n");
                }

                response.append("  内容摘要: ").append(
                                event.getEventContent() != null && event.getEventContent().length() > 100 ?
                                        event.getEventContent().substring(0, 100) + "..." :
                                        event.getEventContent())
                        .append("\n");
                response.append("\n");
            }

            if (events.size() > 5) {
                response.append("还有 ").append(events.size() - 5).append(" 条相关记录未显示，请缩小查询范围获取更精确的结果。\n\n");
            }
        }

        return response.toString();
    }

    /**
     * 根据多条件查询事件列表
     *
     * @param eventName     事件名称（模糊匹配）
     * @param eventType     事件类型
     * @param relatedPerson 相关人物
     * @param timeStartStr  时间范围开始字符串（格式：yyyy-MM-dd 或 yyyy-MM-dd HH:mm:ss）
     * @param timeEndStr    时间范围结束字符串（格式：yyyy-MM-dd 或 yyyy-MM-dd HH:mm:ss）
     * @return 事件列表
     */
    @GetMapping("/list")
    public RestWebResponse<List<Event>> getEvents(
            @RequestParam(required = false) String eventName,
            @RequestParam(required = false) String eventType,
            @RequestParam(required = false) String relatedPerson,
            @RequestParam(required = false) String timeStartStr,
            @RequestParam(required = false) String timeEndStr) {

        LocalDateTime timeStart = null;
        LocalDateTime timeEnd = null;

        if (timeStartStr != null && !timeStartStr.isEmpty()) {
            timeStart = parseDateTime(timeStartStr);
        }
        if (timeEndStr != null && !timeEndStr.isEmpty()) {
            timeEnd = parseDateTime(timeEndStr);
        }
        QueryWrapper<Event> wrapper = new QueryWrapper<>();
        if (eventName != null && !eventName.isEmpty()) {
            wrapper.like("event_name", eventName);
        }
        if (eventType != null && !eventType.isEmpty()) {
            wrapper.like("event_type", eventType);
        }
        if (relatedPerson != null && !relatedPerson.isEmpty()) {
            wrapper.like("related_person", relatedPerson);
        }
        if (timeStart != null) {
            wrapper.ge("time_start", timeStart);
        }
        if (timeEnd != null) {
            wrapper.le("time_end", timeEnd);
        }
        wrapper.orderByDesc("create_time");

        List<Event> events = eventMapper.selectList(wrapper);
        return RestWebResponse.success(events);
    }

    /**
     * 根据多条件查询事件列表（带分页）
     *
     * @param timeStartStr 时间范围开始字符串（格式：yyyy-MM-dd 或 yyyy-MM-dd HH:mm:ss）
     * @param timeEndStr   时间范围结束字符串（格式：yyyy-MM-dd 或 yyyy-MM-dd HH:mm:ss）
     * @param pageNum      页码，默认为1
     * @param pageSize     每页大小，默认为10
     * @return 分页事件列表
     */
    @GetMapping("/pageList")
    public RestWebResponse<IPage<Event>> getEventsWithPage(
            @RequestParam(required = false) String creator,
            @RequestParam(required = false) String eventContent,
            @RequestParam(required = false) String eventType,
            @RequestParam(required = false) String timeStartStr,
            @RequestParam(required = false) String timeEndStr,
            @RequestParam(required = false) String createTimeStartStr,
            @RequestParam(required = false) String createTimeEndStr,
            @RequestParam(required = false) String updateTimeStartStr,
            @RequestParam(required = false) String updateTimeEndStr,
            @RequestParam(defaultValue = "1") Integer pageNum,
            @RequestParam(defaultValue = "10") Integer pageSize) {

        LocalDateTime timeStart = null;
        LocalDateTime timeEnd = null;
        LocalDateTime createTimeStart = null;
        LocalDateTime createTimeEnd = null;
        LocalDateTime updateTimeStart = null;
        LocalDateTime updateTimeEnd = null;

        if (timeStartStr != null && !timeStartStr.isEmpty()) {
            timeStart = parseDateTime(timeStartStr);
        }
        if (timeEndStr != null && !timeEndStr.isEmpty()) {
            timeEnd = parseDateTime(timeEndStr);
        }
        if (createTimeStartStr != null && !createTimeStartStr.isEmpty()) {
            createTimeStart = parseDateTime(createTimeStartStr);
        }
        if (createTimeEndStr != null && !createTimeEndStr.isEmpty()) {
            createTimeEnd = parseDateTime(createTimeEndStr);
        }
        if (updateTimeStartStr != null && !updateTimeStartStr.isEmpty()) {
            updateTimeStart = parseDateTime(updateTimeStartStr);
        }
        if (updateTimeEndStr != null && !updateTimeEndStr.isEmpty()) {
            updateTimeEnd = parseDateTime(updateTimeEndStr);
        }

        // 创建分页对象
        IPage<Event> page = new Page<>(pageNum, pageSize);

        QueryWrapper<Event> wrapper = new QueryWrapper<>();
        if (creator != null && !creator.isEmpty()) {
            wrapper.like("creator", creator);
        }
        if (eventContent != null && !eventContent.isEmpty()) {
            wrapper.like("event_content", eventContent);
        }
        if (eventType != null && !eventType.isEmpty()) {
            wrapper.like("event_type", eventType);
        }
        if (timeStart != null) {
            wrapper.ge("time_start", timeStart);
        }
        if (timeEnd != null) {
            wrapper.le("time_end", timeEnd);
        }
        if (createTimeStart != null) {
            wrapper.ge("create_time", createTimeStart);
        }
        if (createTimeEnd != null) {
            wrapper.le("create_time", createTimeEnd);
        }
        if (updateTimeStart != null) {
            wrapper.ge("update_time", updateTimeStart);
        }
        if (updateTimeEnd != null) {
            wrapper.le("update_time", updateTimeEnd);
        }
        wrapper.orderByDesc("create_time");

        // 执行分页查询
        IPage<Event> result = eventMapper.selectPage(page, wrapper);
        return RestWebResponse.success(result);
    }

    /**
     * 解析日期时间字符串，支持两种格式：
     * 1. yyyy-MM-dd（日期格式）
     * 2. yyyy-MM-dd HH:mm:ss（日期时间格式）
     *
     * @param dateTimeStr 日期时间字符串
     * @return 解析后的LocalDateTime对象，解析失败返回null
     */
    private LocalDateTime parseDateTime(String dateTimeStr) {
        if (dateTimeStr == null || dateTimeStr.trim().isEmpty()) {
            return null;
        }

        // 先尝试解析完整的日期时间格式
        try {
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            return LocalDateTime.parse(dateTimeStr.trim(), formatter);
        } catch (DateTimeParseException e) {
            // 如果失败，则尝试解析仅日期格式
            try {
                DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
                LocalDate date = LocalDate.parse(dateTimeStr.trim(), formatter);
                return date.atStartOfDay(); // 转换为当天的开始时间
            } catch (DateTimeParseException ex) {
                return null;
            }
        }
    }

    /**
     * 智能问答接口 - 根据BIS系统分析的文本意图查询事件
     *
     * @param request 请求体，包含分析后的字段信息
     * @return 匹配的事件列表
     */
    @PostMapping("/smart-query")
    public RestWebResponse<List<Event>> smartQuery(@RequestBody Map<String, Object> request) {
        String relatedPerson = (String) request.get("related_person");
        String timeStartStr = (String) request.get("time_start");
        String timeEndStr = (String) request.get("time_end");
        String eventContent = (String) request.get("event_content");

        QueryWrapper<Event> wrapper = new QueryWrapper<>();

        // 根据相关人员查询（支持多个，用逗号分隔）
        if (relatedPerson != null && !relatedPerson.isEmpty()) {
            String[] persons = relatedPerson.split(",");
            boolean first = true;
            for (String person : persons) {
                String trimmed = person.trim();
                if (!trimmed.isEmpty()) {
                    if (first) {
                        wrapper.like("related_person", trimmed);
                        first = false;
                    } else {
                        wrapper.or().like("related_person", trimmed);
                    }
                }
            }
        }

        // 根据事件内容查询
        if (eventContent != null && !eventContent.isEmpty()) {
            wrapper.like("event_content", eventContent);
        }

        // 根据开始时间查询
        if (timeStartStr != null && !timeStartStr.isEmpty()) {
            LocalDateTime timeStart = parseBisDateTime(timeStartStr);
            if (timeStart != null) {
                wrapper.ge("time_start", timeStart);
            }
        }

        // 根据结束时间查询
        if (timeEndStr != null && !timeEndStr.isEmpty()) {
            LocalDateTime timeEnd = parseBisDateTime(timeEndStr);
            if (timeEnd != null) {
                wrapper.le("time_end", timeEnd);
            }
        }

        wrapper.orderByDesc("create_time");
        wrapper.last("LIMIT 20"); // 限制最多返回20条记录

        List<Event> events = eventMapper.selectList(wrapper);
        return RestWebResponse.success(events);
    }

    /**
     * 解析BIS系统返回的时间格式字符串
     * 支持格式: yyyy-MM-dd HH:mm
     *
     * @param dateTimeStr BIS系统返回的时间字符串
     * @return 解析后的LocalDateTime对象
     */
    private LocalDateTime parseBisDateTime(String dateTimeStr) {
        try {
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
            return LocalDateTime.parse(dateTimeStr, formatter);
        } catch (Exception e) {
            // 如果解析失败，尝试其他常见格式
            try {
                DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
                LocalDate date = LocalDate.parse(dateTimeStr, formatter);
                return date.atStartOfDay();
            } catch (Exception ex) {
                // 所有解析都失败则返回null
                return null;
            }
        }
    }

    /**
     * 根据ID获取事件详情
     *
     * @param id 事件ID
     * @return 事件详情
     */
    @GetMapping("/getEvent/{id}")
    public RestWebResponse<Event> getEventDetail(@PathVariable Integer id) {
        Event event = eventMapper.selectById(id);
        return RestWebResponse.success(event);
    }

    /**
     * 固定问答接口 - 根据固定问题返回预设答案及相关信息
     *
     * @param question 用户提问的问题
     * @return 包含意图、实体、时间和事件信息的固定回答
     */
    @GetMapping("/fixed-chat")
    public RestWebResponse<JSONObject> fixedChat(@RequestParam(required = false) String question) {
        // 如果问题为空，直接返回
        if (question == null || question.trim().isEmpty()) {
            return RestWebResponse.success(null);
        }

        // 查询所有事件
        List<Event> allEvents = eventMapper.selectList(new QueryWrapper<>());

        // 存储匹配度大于0.6的事件及其匹配度
        Map<Event, Double> matchedEvents = new HashMap<>();

        // 遍历所有事件，计算与问题的相似度
        for (Event event : allEvents) {
            String eventName = event.getEventName();
            if (eventName != null && !eventName.isEmpty()) {
                // 计算相似度
                double similarity = calculateSimilarity(question, eventName);
                // 如果相似度大于0.1，加入匹配列表
                if (similarity > 0.1) {
                    matchedEvents.put(event, similarity);
                }
            }
        }

        // 如果没有匹配的事件，返回空结果
        if (matchedEvents.isEmpty()) {
            return RestWebResponse.success(null);
        }

        // 找到匹配度最高的事件
        Event bestMatchEvent = matchedEvents.entrySet().stream()
                .max(Map.Entry.comparingByValue())
                .map(Map.Entry::getKey)
                .orElse(null);

        // 如果找到了匹配度最高的事件，则组装返回结果
        if (bestMatchEvent != null) {
            JSONObject responseJson = new JSONObject();

            // 构造回答文本
            String defaultAnswer = "根据您的问题\"" + question + "\"为您找到最相关的信息：\n\n" +
                    "【事件详情】\n" +
                    "名称: " + bestMatchEvent.getEventName() + "\n" +
                    "类型: " + bestMatchEvent.getEventType() + "\n" +
                    "相关人员: " + bestMatchEvent.getRelatedPerson() + "\n" +
                    "开始时间: " + (bestMatchEvent.getTimeStart() != null ? bestMatchEvent.getTimeStart().toLocalDate() : "") + "\n" +
                    "结束时间: " + (bestMatchEvent.getTimeEnd() != null ? bestMatchEvent.getTimeEnd().toLocalDate() : "") + "\n" +
                    "内容摘要: " + bestMatchEvent.getEventContent() + "\n" +
                    "知识信息: " + bestMatchEvent.getKnowledgeInfo() + "\n\n" +
                    "该事件已成功完成，达到了预期目标。";

            // 设置返回数据
            responseJson.put("response", defaultAnswer);
            responseJson.put("intent", "查找" + question);
            responseJson.put("entity", bestMatchEvent.getEventName());
            responseJson.put("time", bestMatchEvent.getTimeStart() != null ? bestMatchEvent.getTimeStart().toLocalDate() : "");
            responseJson.put("event", bestMatchEvent);

            return RestWebResponse.success(responseJson);
        }

        return RestWebResponse.success(null);
    }

    /**
     * 计算两个字符串之间的相似度（基于编辑距离算法）
     *
     * @param str1 字符串1
     * @param str2 字符串2
     * @return 相似度（0-1之间）
     */
    private double calculateSimilarity(String str1, String str2) {
        if (str1 == null || str2 == null) {
            return 0.0;
        }

        // 计算编辑距离
        int[][] distance = new int[str1.length() + 1][str2.length() + 1];

        for (int i = 0; i <= str1.length(); i++) {
            distance[i][0] = i;
        }

        for (int j = 0; j <= str2.length(); j++) {
            distance[0][j] = j;
        }

        for (int i = 1; i <= str1.length(); i++) {
            for (int j = 1; j <= str2.length(); j++) {
                if (str1.charAt(i - 1) == str2.charAt(j - 1)) {
                    distance[i][j] = distance[i - 1][j - 1];
                } else {
                    distance[i][j] = Math.min(Math.min(distance[i - 1][j], distance[i][j - 1]), distance[i - 1][j - 1]) + 1;
                }
            }
        }

        // 计算相似度
        return 1 - (double) distance[str1.length()][str2.length()] / Math.max(str1.length(), str2.length());
    }

    /**
     * 新增事件
     *
     * @param event 事件对象
     * @return 添加结果
     */
    @PostMapping("/add")
    public RestWebResponse<String> addEvent(@RequestBody Event event) {
        // 设置创建时间
        if (event.getCreateTime() == null) {
            event.setCreateTime(LocalDateTime.now());
        }

        // 插入数据库
        int result = eventMapper.insert(event);

        if (result > 0) {
            return RestWebResponse.success("事件添加成功");
        } else {
            return new RestWebResponse<>("500", "事件添加失败", null);
        }
    }

    /**
     * 批量新增事件
     *
     * @param events 事件对象列表
     * @return 添加结果
     */
    @PostMapping("/addList")
    public RestWebResponse<String> addEventList(@RequestBody List<Event> events) {
        int successCount = 0;
        int failCount = 0;

        for (Event event : events) {
            // 设置创建时间
            if (event.getCreateTime() == null) {
                event.setCreateTime(LocalDateTime.now());
            }

            // 插入数据库
            int result = eventMapper.insert(event);

            if (result > 0) {
                successCount++;
            } else {
                failCount++;
            }
        }

        if (failCount == 0) {
            return RestWebResponse.success("成功添加" + successCount + "个事件");
        } else {
            return new RestWebResponse<>("206", "部分事件添加成功，成功" + successCount + "个，失败" + failCount + "个",
                    "成功:" + successCount + ",失败:" + failCount);
        }
    }

    /**
     * 编辑事件
     *
     * @param event 更新的事件对象
     * @return 编辑结果
     */
    @PostMapping("/updateEvent")
    public RestWebResponse<String> updateEvent(@RequestBody Event event) {
        // 检查事件是否存在
        Event existingEvent = eventMapper.selectById(event.getId());
        if (existingEvent == null) {
            return new RestWebResponse<>("404", "事件不存在", null);
        }

        // 设置更新时间
        event.setUpdateTime(LocalDateTime.now());
        // 保持创建时间不变
        event.setCreateTime(existingEvent.getCreateTime());
        // 设置ID
        event.setId(event.getId());

        // 更新数据库
        int result = eventMapper.updateById(event);

        if (result > 0) {
            return RestWebResponse.success("事件更新成功");
        } else {
            return new RestWebResponse<>("500", "事件更新失败", null);
        }
    }

    /**
     * 删除事件
     *
     * @param id 事件ID
     * @return 删除结果
     */
    @GetMapping("/deleteEvent/{id}")
    public RestWebResponse<String> deleteEvent(@PathVariable Integer id) {
        // 检查事件是否存在
        Event existingEvent = eventMapper.selectById(id);
        if (existingEvent == null) {
            return new RestWebResponse<>("404", "事件不存在", null);
        }

        // 从数据库删除
        int result = eventMapper.deleteById(id);

        if (result > 0) {
            return RestWebResponse.success("事件删除成功");
        } else {
            return new RestWebResponse<>("500", "事件删除失败", null);
        }
    }

    /**
     * 智能问答接口 - 接收用户问题，调用BIS API分析问题，并根据返回结果查询事件
     *
     * @param request 请求体，包含用户问题
     * @return 匹配的事件列表
     */
    @PostMapping("/intelligent-query")
    public RestWebResponse<List<Event>> intelligentQuery(@RequestBody Map<String, String> request) {
        String question = request.get("question");
        String ollamaUrl = request.getOrDefault("ollama_url", "http://localhost:11434");
        String modelName = request.getOrDefault("model_name", "qwen3:1.7b");

        if (question == null || question.trim().isEmpty()) {
            return new RestWebResponse<>("400", "问题不能为空", null);
        }

        // 调用BIS API分析问题
        JSONObject analysisResult = callBisApi(question, ollamaUrl, modelName);
        if (analysisResult == null) {
            return new RestWebResponse<>("500", "调用BIS API失败", null);
        }

        // 根据分析结果查询事件
        List<Event> events = searchEventsByAnalysisResult(analysisResult);
        return RestWebResponse.success(events);
    }

    /**
     * 调用BIS API分析用户问题
     *
     * @param text      用户问题
     * @param ollamaUrl Ollama服务地址
     * @param modelName 使用的模型名称
     * @return 分析结果
     */
    private JSONObject callBisApi(String text, String ollamaUrl, String modelName) {
        try {
            RestTemplate restTemplate = new RestTemplate();

            // 构造请求URL
            String url = ollamaUrl + "/api/generate";

            // 构造请求体
            JSONObject requestBody = new JSONObject();
            requestBody.put("model", modelName);

            // 构造prompt，模拟BIS API的行为
            String prompt = String.format("分析以下文本并以JSON格式返回结构化信息，包含以下字段：related_person(相关人物), time_start(开始时间), time_end(结束时间), event_content(事件详情)。文本：%s", text);
            requestBody.put("prompt", prompt);
            requestBody.put("stream", false);

            // 设置请求头
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);
            HttpEntity<String> entity = new HttpEntity<>(requestBody.toJSONString(), headers);

            // 发送POST请求
            ResponseEntity<String> response = restTemplate.postForEntity(url, entity, String.class);

            if (response.getStatusCode() == HttpStatus.OK) {
                JSONObject responseObject = JSON.parseObject(response.getBody());
                String responseText = responseObject.getString("response");
                if (responseText != null) {
                    return JSON.parseObject(responseText);
                }
                // 如果没有response字段，尝试直接解析
                return responseObject;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 根据BIS API分析结果查询事件
     *
     * @param analysisResult BIS API分析结果
     * @return 匹配的事件列表
     */
    private List<Event> searchEventsByAnalysisResult(JSONObject analysisResult) {
        String relatedPerson = analysisResult.getString("related_entity");
        String timeStartStr = analysisResult.getString("time_start");
        String timeEndStr = analysisResult.getString("time_end");
        String eventContent = analysisResult.getString("event_content");

        QueryWrapper<Event> wrapper = new QueryWrapper<>();

        // 根据相关人员查询（支持多个，用逗号分隔）
        if (relatedPerson != null && !relatedPerson.isEmpty()) {
            String[] persons = relatedPerson.split(",");
            boolean first = true;
            for (String person : persons) {
                String trimmed = person.trim();
                if (!trimmed.isEmpty()) {
                    if (first) {
                        wrapper.like("related_person", trimmed);
                        first = false;
                    } else {
                        wrapper.or().like("related_person", trimmed);
                    }
                }
            }
        }

        // 根据事件内容查询
        if (eventContent != null && !eventContent.isEmpty()) {
            wrapper.like("event_content", eventContent);
        }

        // 根据开始时间查询
        if (timeStartStr != null && !timeStartStr.isEmpty()) {
            LocalDateTime timeStart = parseDateTime(timeStartStr);
            if (timeStart != null) {
                wrapper.ge("time_start", timeStart);
            }
        }

        // 根据结束时间查询
        if (timeEndStr != null && !timeEndStr.isEmpty()) {
            LocalDateTime timeEnd = parseDateTime(timeEndStr);
            if (timeEnd != null) {
                wrapper.le("time_end", timeEnd);
            }
        }

        wrapper.orderByDesc("create_time");
        wrapper.last("LIMIT 20"); // 限制最多返回20条记录

        return eventMapper.selectList(wrapper);
    }

    /**
     * @param question
     * @return
     */
    @GetMapping("/llm-chat")
    public RestWebResponse<JSONObject> llmChat(@RequestParam String question) {
        // 如果问题为空，直接返回
        if (question == null || question.trim().isEmpty()) {
            return RestWebResponse.success(null);
        }

        //查询大模型
        AnalysisResult result = AnalyzeLLMApi.analyzeTextApi(question);

        String timeStartStr = result.getTimeStart();
        String timeEndStr = result.getTimeEnd();

        QueryWrapper<Event> wrapper = new QueryWrapper<>();
        // 根据开始时间查询
        if (timeStartStr != null && !timeStartStr.isEmpty()) {
            LocalDateTime timeStart = parseBisDateTime(timeStartStr);
            if (timeStart != null) {
                wrapper.ge("time_start", timeStart);
            }
        }

        // 根据结束时间查询
        if (timeEndStr != null && !timeEndStr.isEmpty()) {
            LocalDateTime timeEnd = parseBisDateTime(timeEndStr);
            if (timeEnd != null) {
                wrapper.le("time_end", timeEnd);
            }
        }

        // 查询所有事件
        List<Event> allEvents = eventMapper.selectList(wrapper);

        // 存储匹配度大于阈值的事件及其匹配度
        Map<Event, Double> matchedEvents = new HashMap<>();

        // 遍历所有事件，计算与问题的相似度
        for (Event event : allEvents) {
            // 计算综合相似度
            double similarity = calculateComprehensiveSimilarity(result, event);
            // 如果相似度大于阈值，加入匹配列表
            if (similarity > 0.03) { // 提高阈值以减少不相关结果
                matchedEvents.put(event, similarity);
            }
        }

        // 如果没有匹配的事件，返回空结果
        if (matchedEvents.isEmpty()) {
            return RestWebResponse.success(null);
        }

        // 找到匹配度最高的事件
        Event bestMatchEvent = matchedEvents.entrySet().stream()
                .max(Map.Entry.comparingByValue())
                .map(Map.Entry::getKey)
                .orElse(null);

        // 如果找到了匹配度最高的事件，则组装返回结果
        if (bestMatchEvent != null) {
            JSONObject responseJson = new JSONObject();

            // 构造回答文本
            String defaultAnswer = "根据您的问题\"" + question + "\"为您找到最相关的信息：\n\n" +
                    "【事件详情】\n" +
                    "名称: " + bestMatchEvent.getEventName() + "\n" +
                    "类型: " + bestMatchEvent.getEventType() + "\n" +
                    "相关人员: " + bestMatchEvent.getRelatedPerson() + "\n" +
                    "开始时间: " + (bestMatchEvent.getTimeStart() != null ? bestMatchEvent.getTimeStart().toLocalDate() : "") + "\n" +
                    "结束时间: " + (bestMatchEvent.getTimeEnd() != null ? bestMatchEvent.getTimeEnd().toLocalDate() : "") + "\n" +
                    "内容摘要: " + bestMatchEvent.getEventContent() + "\n" +
                    "知识信息: " + bestMatchEvent.getKnowledgeInfo() + "\n\n" +
                    "该事件已成功完成，达到了预期目标。";

            // 设置返回数据
            responseJson.put("response", defaultAnswer);
            responseJson.put("intent", "查找" + question);
            responseJson.put("entity", bestMatchEvent.getEventName());
            responseJson.put("time", bestMatchEvent.getTimeStart() != null ? bestMatchEvent.getTimeStart().toLocalDate() : "");
            responseJson.put("event", bestMatchEvent);

            return RestWebResponse.success(responseJson);
        }

        return RestWebResponse.success(null);
    }

    /**
     * 计算综合相似度（结合多种算法）
     *
     * @param analysisResult 分析结果对象
     * @param event          事件对象
     * @return 综合相似度（0-1之间）
     */
    private double calculateComprehensiveSimilarity(AnalysisResult analysisResult, Event event) {
        // 获取事件各字段内容
        //事件名称
        String eventName = event.getEventName() != null ? event.getEventName() : "";
        //事件类型（直接存名称，如"安全事件""业务事件"）
        String eventTypeName = event.getEventTypeName() != null ? event.getEventTypeName() : "";
        //事件内容详情
        String eventContent = event.getEventContent() != null ? event.getEventContent() : "";
        //相关人物（直接存名称，如"张三""李四"）
        String relatedPerson = event.getRelatedPerson() != null ? event.getRelatedPerson() : "";

        // 使用AnalysisResult中的相关实体和事件内容计算相似度
        String relatedEntity = analysisResult.getRelatedEntity() != null ? analysisResult.getRelatedEntity().trim() : "";
        String analysisEventContent = analysisResult.getEventContent() != null ? analysisResult.getEventContent() : "";


        // 计算各字段的相似度
        double nameSimilarity = calculateSimilarity(relatedEntity, eventName);
        double typeSimilarity = calculateSimilarity(relatedEntity, eventTypeName);
        double contentSimilarity = calculateSimilarity(analysisEventContent, eventContent);
        double personSimilarity = calculateSimilarity(relatedEntity, relatedPerson);

        // 加权计算综合相似度 (可以根据实际效果调整权重)
        double comprehensiveScore;
        if (relatedEntity.isEmpty()) {
            // 当相关实体为空时，重新调整权重，增加事件内容的权重
            comprehensiveScore = 0.2 * nameSimilarity +
                    0.2 * typeSimilarity +
                    0.5 * contentSimilarity +
                    0.1 * personSimilarity;
        } else {
            // 正常情况下的权重分配
            comprehensiveScore = 0.35 * nameSimilarity +
                    0.25 * typeSimilarity +
                    0.25 * contentSimilarity +
                    0.15 * personSimilarity;
        }

        // 计算Jaccard相似度作为补充
        String combinedText = eventName + " " + eventTypeName + " " + eventContent + " " + relatedPerson;
        String combinedAnalysis = relatedEntity + " " + analysisEventContent;
        double jaccardScore = calculateJaccardSimilarity(combinedAnalysis, combinedText);
        // 结合Jaccard相似度进行调整
        double finalScore = 0.8 * comprehensiveScore + 0.2 * jaccardScore;

        return finalScore;
    }

    /**
     * 计算Jaccard相似度
     *
     * @param str1 字符串1
     * @param str2 字符串2
     * @return Jaccard相似度（0-1之间）
     */
    private double calculateJaccardSimilarity(String str1, String str2) {
        if (str1 == null || str2 == null || str1.isEmpty() || str2.isEmpty()) {
            return 0.0;
        }

        // 分词并转为小写
        Set<String> set1 = new HashSet<>(Arrays.asList(str1.toLowerCase().split("[\\s\\p{Punct}]+")));
        Set<String> set2 = new HashSet<>(Arrays.asList(str2.toLowerCase().split("[\\s\\p{Punct}]+")));

        // 移除空字符串
        set1.removeIf(String::isEmpty);
        set2.removeIf(String::isEmpty);

        // 计算交集和并集
        Set<String> intersection = new HashSet<>(set1);
        intersection.retainAll(set2);

        Set<String> union = new HashSet<>(set1);
        union.addAll(set2);

        if (union.isEmpty()) {
            return 0.0;
        }

        // 计算Jaccard相似度
        return (double) intersection.size() / union.size();
    }
}